package com.yyh2;
/*、声明一个接口：Selector，包含抽象方法：
	（1）boolean hasNext()
	（2）Object next()
	2、声明一个接口：Touchable，包含抽象方法：
	（1）Selector select()
	3、声明一个MyArrayList类，当做容器类使用，模拟动态数组数据结构的容器
	（1）包含私有属性：
	①Object[] all；用于保存对象，初始化长度为2
	②int total；记录实际存储的对象个数
	（2）包含方法：
	①public void add(Object element)：用于添加一个元素到当前容器中，如果数组all已满，就扩容为原来的2倍
	②public void remove(int index)：如果index<0或index>=total就打印“没有这个元素”并返回，否则删除index位置的元素
	③public void set(int index, Object value)：如果index<0或index>=total就打印“没有这个元素”并返回，否则就替换index位置的元素为value
	④public Object get(int index)：如果index<0或index>=total就打印“没有这个元素”并返回null，否则返回index位置的元素
	⑤让类MyArrayList实现Touchable接口，并重写Selector select()方法，返回内部类MySelector的对象
	⑥在类MyArrayList中声明private的内部类MySelector，实现Selector接口
	A：在内部类MySelector声明一个属性：int cursor（游标）
	B：MySelector实现Selector接口，并重写两个抽象方法，其中
- 		boolean hasNext()实现为：return cursor != total
  		Object next()实现为：return all[cursor++]
4、在测试类Test06_01中,
（1）创建MyArrayList的对象list
（2）调用list的add方法，添加3个对象
（3）调用list的remove方法，删除[1]的对象
（4）调用list的set方法，替换[1]的对象
（5）调用list的get方法，获取[1]的对象
（6）调用list的select方法，获取Selector的对象，并调用hasNext()和next()遍历容器中所有的对象
*/
public class Demo4 {
    public static void main(String[] args) {
        //创建MyArrayList的对象list
        MyArrayList list = new MyArrayList();
        //添加3个对象
        list.add("张三");
        list.add("李四");
        list.add("王五");
        System.out.println("添加3个对象成功！");
        //删除[1]的对象
        list.remove(1);
        System.out.println("删除[1]的对象成功！");
        //替换[1]的对象
        list.set(1, "赵六");
        System.out.println("替换[1]的对象成功！");
        //获取[1]的对象
        System.out.println(list.get(1));
        System.out.println("获取[1]的对象成功！");
    }
}
//声明一个接口Selector
interface Selector {
    boolean hasNext();
    Object next();
}
//声明一个接口Touchable
interface Touchable {
    Selector select();
}
//声明一个MyArrayList类，当做容器类使用，模拟动态数组数据结构的容器
class MyArrayList implements Touchable {
    private Object[] all = new Object[2];
    private int total = 0;
    public void add(Object element) {
        if (total == all.length) {
            Object[] newAll = new Object[all.length * 2];
            for (int i = 0; i < all.length; i++) {
                newAll[i] = all[i];
            }
            all = newAll;
        }
    }
    //添加一个元素到当前容器中，如果数组all已满，就扩容为原来的2倍
    public void add1(Object element) {
        if (total == all.length) {
            Object[] newAll = new Object[all.length * 2];
            for (int i = 0; i < all.length; i++) {
                newAll[i] = all[i];
            }
            all = newAll;
        }
        all[total] = element;
        total++;
    }
    //如果index<0或index>=total就打印“没有这个元素”并返回，否则删除index位置的元素
    public void remove(int index) {
        if (index < 0 || index >= total) {
            System.out.println("没有这个元素");
            return;
        }
        for (int i = index; i < total - 1; i++) {
            all[i] = all[i + 1];
        }
        total--;
    }
    //如果index<0或index>=total就打印“没有这个元素”并返回，否则就替换index位置的元素为value
    public void set(int index, Object value) {
        if (index < 0 || index >= total) {
            System.out.println("没有这个元素");
            return;
        }
        all[index] = value;
    }
    //如果index<0或index>=total就打印“没有这个元素”并返回null，否则返回index位置的元素
    public Object get(int index) {
        if (index < 0 || index >= total) {
            System.out.println("没有这个元素");
            return null;
        }
        return all[index];
    }
    //让类MyArrayList实现Touchable接口，并重写Selector select()方法，返回内部类MySelector的对象
    @Override
    public Selector select() {
        return new MySelector();
    }
    //在类MyArrayList中声明private的内部类MySelector，实现Selector接口
    private class MySelector implements Selector {
        private int cursor = 0;
        @Override
        public boolean hasNext() {
            return cursor != total;
        }
        @Override
        public Object next() {
            return all[cursor++];
        }
    }

}

